home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / wwbbs31_source.lha / WWBBS / BBSPrefsSrc / bbsprefs.c < prev    next >
C/C++ Source or Header  |  1995-06-27  |  48KB  |  1,509 lines
  1. #include <exec/types.h>
  2. #include <exec/exec.h>
  3. #include <graphics/displayinfo.h>
  4. #include <intuition/gadgetclass.h>
  5. #include <intuition/intuition.h>
  6. #include <libraries/asl.h>
  7. #include <libraries/triton.h>
  8. #include <libraries/wwbbs.h>
  9. #include <workbench/workbench.h>
  10. #include <workbench/startup.h>
  11. #include <ctype.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15.  
  16. #include <proto/asl.h>
  17. #include <proto/dos.h>
  18. #include <proto/exec.h>
  19. #include <proto/icon.h>
  20. #include <proto/intuition.h>
  21. #include <proto/triton.h>
  22. #include <proto/wwbbs.h>
  23.  
  24. #include "bbsprefs.h"
  25.  
  26. #include "bbsprefs_rev.h"
  27.  
  28. char *version=VERSTAG;
  29.  
  30. long __stack=20000;
  31.  
  32. struct Library *AslBase;
  33. struct Library *WorldWideBase;
  34.  
  35. void close_all(void);
  36. void Prefs(UWORD);
  37. void error_request(struct TR_Project *,BYTE *);
  38. struct List *CreateList(BYTE *);
  39. void DeleteList(struct List *);
  40. struct Node *GetNode(struct List *,ULONG);
  41. ULONG GetNodeNum(struct List *,BYTE *);
  42. void update_gadgets(struct TR_Project *,UWORD,BYTE *,struct List *,ULONG);
  43. BOOL process_prefs_gadgets(struct TR_Project *,BYTE *,BYTE *,UWORD,ULONG,ULONG);
  44. BOOL asl_file_requester(struct TR_Project *,BYTE *,BYTE *,BYTE *,BYTE *);
  45. BOOL asl_drawer_requester(struct TR_Project *,BYTE *,BYTE *,BYTE *);
  46. void set_defaults(BYTE *,BYTE *,UWORD);
  47.  
  48. #define update_gadget(project,id,data,node) TR_SetAttribute(project,id,0,(ULONG)data);TR_SetAttribute(project,id,TRAT_Disabled,(node) ? FALSE : TRUE)
  49. #define update_integer_gadget(project,id,buff,data,node) sprintf(buff,"%ld",(ULONG)data);TR_SetAttribute(project,id,0,(ULONG)buff);TR_SetAttribute(project,id,TRAT_Disabled,(node) ? FALSE : TRUE)
  50. #define update_cycle_gadget(project,id,data,node) TR_SetAttribute(project,id,TRAT_Value,(ULONG)data);TR_SetAttribute(project,id,TRAT_Disabled,(node) ? FALSE : TRUE)
  51. #define update_checkbox_gadget(project,id,data,node) TR_SetAttribute(project,id,TRAT_Value,(ULONG)data);TR_SetAttribute(project,id,TRAT_Disabled,(node) ? FALSE : TRUE)
  52. #define update_text_gadget(project,id,data,node) TR_SetAttribute(project,id,TRAT_Text,(ULONG)data);TR_SetAttribute(project,id,TRAT_Disabled,(node) ? FALSE : TRUE)
  53.  
  54. #define set_config(tag,data) SetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,CFGTAG_DontSave,TRUE,tag,(APTR) data,TAG_END)
  55.  
  56. void main(int argc,char **argv)
  57.     {
  58.         if(TR_OpenTriton(TRITON10VERSION,TRCA_Name,"BBSPrefs",TRCA_LongName,"BBS Preferences",TRCA_Info,"WWBBS Preferences",TRCA_Version,"2",TRCA_Release,"1",TRCA_Date,DATE,TAG_END))
  59.             {
  60.  
  61.         if(!(AslBase=OpenLibrary("asl.library",0)))
  62.             close_all();
  63.         if(!(WorldWideBase=OpenLibrary("wwbbs.library",0)))
  64.             close_all();
  65.  
  66.         {
  67.             UBYTE **tooltypes,*p;
  68.             tooltypes=ArgArrayInit(argc,argv);
  69.             p=ArgString(tooltypes,"FILEBASEDIRECTORY","");
  70.             if(strlen(p)>255)
  71.                 p="";
  72.             strcpy(default_directory,p);
  73.             p=ArgString(tooltypes,"MESSAGEBASEQUOTEHEADER","In a message dated %d, %n wrote:");
  74.             if(strlen(p)>80)
  75.                 p="In a message dated %d, %n wrote:";
  76.             strcpy(default_quote_header,p);
  77.             p=ArgString(tooltypes,"NODECOMMAND","WWBBS:BBSRx WWBBS:Rexx/Session.rexx");
  78.             if(strlen(p)>255)
  79.                 p="WWBBS:BBSRx WWBBS:Rexx/Session.rexx";
  80.             strcpy(default_node_command,p);
  81.             ArgArrayDone();
  82.         }
  83.  
  84.         {
  85.             struct TR_Project *project;
  86.             if(project=TR_OpenProject(Application,bbsprefs_trwintags))
  87.                 {
  88.                     BOOL kg=TRUE;
  89.                     while(kg)
  90.                         {
  91.                             TR_Wait(Application,0);
  92.                             {
  93.                                 struct TR_Message *msg;
  94.                                 while(kg && (msg=TR_GetMsg(Application)))
  95.                                     {
  96.                                         if(msg->trm_Project==project)
  97.                                             {
  98.                                                 switch(msg->trm_Class)
  99.                                                     {
  100.                                                         case TRMS_CLOSEWINDOW:
  101.                                                             kg=FALSE;
  102.                                                             break;
  103.                                                         case TRMS_NEWVALUE:
  104.                                                             switch(msg->trm_ID)
  105.                                                                 {
  106.                                                                     case 1: /* List */
  107.                                                                         TR_LockProject(project);
  108.                                                                         Prefs(msg->trm_Data);
  109.                                                                         TR_UnlockProject(project);
  110.                                                                         break;
  111.                                                                 }
  112.                                                             break;
  113.                                                         case TRMS_ACTION:
  114.                                                             switch(msg->trm_ID)
  115.                                                                 {
  116.                                                                     case 101: /* About... */
  117.                                                                         {
  118.                                                                             char s[256];
  119.                                                                             sprintf(s,"%%3BBS Preferences 2.5 (%s)\n%%nCopyright ⌐ 1995 Arthur Choung\tInternet: choung@seas.ucla.edu or arthur@qedbbs.com\nUS Mail: 10324 Chestnut Street, Bellflower, CA 90706 USA",DATE);
  120.                                                                             TR_EasyRequestTags(Application,s,"Okay",TREZ_ReqPos,TRWP_CENTERDISPLAY,TREZ_LockProject,project,TREZ_Title,"About World Wide BBS...",TAG_END);
  121.                                                                         }
  122.                                                                         break;
  123.                                                                     case 102: /* Quit */
  124.                                                                         kg=FALSE;
  125.                                                                 }
  126.                                                             break;
  127.                                                     }
  128.                                             }
  129.                                         TR_ReplyMsg(msg);
  130.                                     }
  131.                             }
  132.                         }
  133.                     TR_CloseProject(project);
  134.                 }
  135.             else
  136.                 TR_EasyRequestTags(Application,TR_GetErrorString(TR_GetLastError(Application)),"Okay",TREZ_ReqPos,TRWP_CENTERDISPLAY,TREZ_Title,"World Wide BBS Error Request",TAG_END);
  137.         }
  138.  
  139.         SetConfigTags(CFGTAG_ForceSave,TRUE,TAG_END);
  140.         close_all();
  141.  
  142.             }
  143.         exit(0);
  144.     }
  145.  
  146. void close_all()
  147.     {
  148.         if(AslBase) CloseLibrary(AslBase);
  149.         if(WorldWideBase) CloseLibrary(WorldWideBase);
  150.         TR_CloseTriton();
  151.         exit(0);
  152.     }
  153.  
  154. void Prefs(UWORD prefsid)
  155.     {
  156.         struct TR_Project *project;
  157.         if(project=TR_OpenProject(Application,prefs_trwintags[prefsid]))
  158.             {
  159.                 BYTE path[512];
  160.                 struct List *list=NULL;
  161.                 strcpy(path,prefs_path[prefsid]);
  162.                 if(prefs_flags[prefsid] & PREFS_ListMode)
  163.                     {
  164.                         if(list=CreateList(path))
  165.                             {
  166.                                 TR_SetAttribute(project,51,0,(ULONG) list);
  167.                                 TR_SetAttribute(project,51,TRAT_Value,0);
  168.                                 update_gadgets(project,prefsid,path,list,0);
  169.                             }
  170.                         else
  171.                             {
  172.                                 char s[256];
  173.                                 sprintf(s,"Unable to create list for `%s'.",path);
  174.                                 error_request(project,s);
  175.                             }
  176.                     }
  177.                 else
  178.                     update_gadgets(project,prefsid,path,NULL,0);
  179.                 {
  180.                     BOOL kg=TRUE;
  181.                     ULONG selected=0;
  182.                     while(kg)
  183.                         {
  184.                             TR_Wait(Application,0);
  185.                             {
  186.                                 struct TR_Message *msg;
  187.                                 while(kg && (msg=TR_GetMsg(Application)))
  188.                                     {
  189.                                         if(msg->trm_Project==project)
  190.                                             {
  191.                                                 switch(msg->trm_Class)
  192.                                                     {
  193.                                                         case TRMS_CLOSEWINDOW:
  194.                                                             kg=FALSE;
  195.                                                             break;
  196.                                                         case TRMS_NEWVALUE:
  197.                                                             switch(msg->trm_ID)
  198.                                                                 {
  199.                                                                     case 51: /* List */
  200.                                                                         if(prefs_flags[prefsid] & PREFS_ListMode)
  201.                                                                             {
  202.                                                                                 if( (msg->trm_Qualifier & IEQUALIFIER_REPEAT) && (prefs_flags[prefsid] & PREFS_TreeMode) )
  203.                                                                                     {
  204.                                                                                         struct Node *node;
  205.                                                                                         if(node=GetNode(list,selected))
  206.                                                                                             {
  207.                                                                                                 TR_SetAttribute(project,51,0,NULL);
  208.                                                                                                 DeleteList(list);
  209.                                                                                                 selected=0;
  210.                                                                                                 if(!AddPart(path,node->ln_Name,511))
  211.                                                                                                     {
  212.                                                                                                         char s[256];
  213.                                                                                                         sprintf(s,"Unable to enter `%s/%s'.",path,node->ln_Name);
  214.                                                                                                         error_request(project,s);
  215.                                                                                                     }
  216.                                                                                                 list=CreateList(path);
  217.                                                                                                 TR_SetAttribute(project,51,0,(ULONG) list);
  218.                                                                                                 TR_SetAttribute(project,51,TRAT_Value,selected);
  219.                                                                                                 update_gadgets(project,prefsid,path,list,selected);
  220.                                                                                             }
  221.                                                                                     }
  222.                                                                                 else
  223.                                                                                     {
  224.                                                                                         selected=msg->trm_Data;
  225.                                                                                         update_gadgets(project,prefsid,path,list,selected);
  226.                                                                                     }
  227.                                                                             }
  228.                                                                         break;
  229.                                                                     case 52: /* Edit */
  230.                                                                         if(prefs_flags[prefsid] & PREFS_ListMode)
  231.                                                                             {
  232.                                                                                 struct Node *node;
  233.                                                                                 if(node=GetNode(list,selected))
  234.                                                                                     {
  235.                                                                                         STRPTR newname=NULL;
  236.                                                                                         newname=(STRPTR) TR_GetAttribute(project,52,0);
  237.                                                                                         if(strcmp(newname,node->ln_Name))
  238.                                                                                             {
  239.                                                                                                 if(SetConfigTags(
  240.                                                                                                         CFGTAG_Path,path,
  241.                                                                                                         CFGTAG_Name,node->ln_Name,
  242.                                                                                                         CFGTAG_NewName,newname,
  243.                                                                                                         CFGTAG_DontSave,TRUE,
  244.                                                                                                         TAG_END))
  245.                                                                                                     {
  246.                                                                                                         TR_SetAttribute(project,51,0,0);
  247.                                                                                                         DeleteList(list);
  248.                                                                                                         selected=0;
  249.                                                                                                         if(list=CreateList(path))
  250.                                                                                                             selected=GetNodeNum(list,newname);
  251.                                                                                                         TR_SetAttribute(project,51,0,(ULONG) list);
  252.                                                                                                         TR_SetAttribute(project,51,TRAT_Value,selected);
  253.                                                                                                     }
  254.                                                                                                 else
  255.                                                                                                     error_request(project,"Unable to set new name.");
  256.                                                                                             }
  257.                                                                                     }
  258.                                                                             }
  259.                                                                         break;
  260.                                                                     default:
  261.                                                                         if(prefs_flags[prefsid] & PREFS_ListMode)
  262.                                                                             {
  263.                                                                                 struct Node *node;
  264.                                                                                 if(node=GetNode(list,selected))
  265.                                                                                     {
  266.                                                                                         if(process_prefs_gadgets(project,path,node->ln_Name,prefsid,msg->trm_ID,msg->trm_Data))
  267.                                                                                             update_gadgets(project,prefsid,path,list,selected);
  268.                                                                                     }
  269.                                                                             }
  270.                                                                         else
  271.                                                                             {
  272.                                                                                 if(process_prefs_gadgets(project,NULL,"System",prefsid,msg->trm_ID,msg->trm_Data))
  273.                                                                                     update_gadgets(project,prefsid,path,list,selected);
  274.                                                                             }
  275.                                                                         break;
  276.                                                                 }
  277.                                                             break;
  278.                                                         case TRMS_ACTION:
  279.                                                             switch(msg->trm_ID)
  280.                                                                 {
  281.                                                                     case 53: /* Parent */
  282.                                                                         if(prefs_flags[prefsid] & PREFS_TreeMode)
  283.                                                                             {
  284.                                                                                 if(strchr(path,'/'))
  285.                                                                                     {
  286.                                                                                         char *p;
  287.                                                                                         if(p=PathPart(path))
  288.                                                                                             {
  289.                                                                                                 TR_SetAttribute(project,51,0,0);
  290.                                                                                                 DeleteList(list);
  291.                                                                                                 selected=0;
  292.                                                                                                 *p=NULL;
  293.                                                                                                 list=CreateList(path);
  294.                                                                                                 TR_SetAttribute(project,51,0,(ULONG) list);
  295.                                                                                                 TR_SetAttribute(project,51,TRAT_Value,selected);
  296.                                                                                                 update_gadgets(project,prefsid,path,list,selected);
  297.                                                                                             }
  298.                                                                                     }
  299.                                                                             }
  300.                                                                         break;
  301.                                                                     case 54: /* Child */
  302.                                                                         if(prefs_flags[prefsid] & PREFS_TreeMode)
  303.                                                                             {
  304.                                                                                 struct Node *node;
  305.                                                                                 if(node=GetNode(list,selected))
  306.                                                                                     {
  307.                                                                                         TR_SetAttribute(project,51,0,0);
  308.                                                                                         DeleteList(list);
  309.                                                                                         selected=0;
  310.                                                                                         if(!AddPart(path,node->ln_Name,511))
  311.                                                                                             {
  312.                                                                                                 char s[256];
  313.                                                                                                 sprintf(s,"Unable to enter `%s/%s'.",path,node->ln_Name);
  314.                                                                                                 error_request(project,s);
  315.                                                                                             }
  316.                                                                                         list=CreateList(path);
  317.                                                                                         TR_SetAttribute(project,51,0,(ULONG) list);
  318.                                                                                         TR_SetAttribute(project,51,TRAT_Value,selected);
  319.                                                                                         update_gadgets(project,prefsid,path,list,selected);
  320.                                                                                     }
  321.                                                                             }
  322.                                                                         break;
  323.                                                                     case 55: /* Add */
  324.                                                                         if(prefs_flags[prefsid] & PREFS_ListMode)
  325.                                                                             {
  326.                                                                                 if(AddConfigTags(
  327.                                                                                         CFGTAG_Path,path,
  328.                                                                                         CFGTAG_Name,"Unnamed",
  329.                                                                                         CFGTAG_Type,prefs_type[prefsid],
  330.                                                                                         CFGTAG_DontSave,TRUE,
  331.                                                                                         TAG_END))
  332.                                                                                     {
  333.                                                                                         set_defaults(path,"Unnamed",prefsid);
  334.                                                                                         TR_SetAttribute(project,51,0,0);
  335.                                                                                         DeleteList(list);
  336.                                                                                         selected=0;
  337.                                                                                         if(list=CreateList(path))
  338.                                                                                             selected=GetNodeNum(list,"Unnamed");
  339.                                                                                         TR_SetAttribute(project,51,0,(ULONG) list);
  340.                                                                                         TR_SetAttribute(project,51,TRAT_Value,selected);
  341.                                                                                         update_gadgets(project,prefsid,path,list,selected);
  342.                                                                                         /* activate gadget */
  343.                                                                                     }
  344.                                                                                 else
  345.                                                                                     {
  346.                                                                                         char s[256];
  347.                                                                                         sprintf(s,"Unable to add to `%s'.",path);
  348.                                                                                         error_request(project,s);
  349.                                                                                     }
  350.                                                                             }
  351.                                                                         break;
  352.                                                                     case 56: /* Delete */
  353.                                                                         if(prefs_flags[prefsid] & PREFS_ListMode)
  354.                                                                             {
  355.                                                                                 struct Node *node;
  356.                                                                                 if(node=GetNode(list,selected))
  357.                                                                                     {
  358.                                                                                         if(RemConfigTags(
  359.                                                                                                 CFGTAG_Path,path,
  360.                                                                                                 CFGTAG_Name,node->ln_Name,
  361.                                                                                                 CFGTAG_DontSave,TRUE,
  362.                                                                                                 TAG_END))
  363.                                                                                             {
  364.                                                                                                 TR_SetAttribute(project,51,0,0);
  365.                                                                                                 DeleteList(list);
  366.                                                                                                 if(selected)
  367.                                                                                                     selected--;
  368.                                                                                                 list=CreateList(path);
  369.                                                                                                 TR_SetAttribute(project,51,0,(ULONG) list);
  370.                                                                                                 TR_SetAttribute(project,51,TRAT_Value,selected);
  371.                                                                                                 update_gadgets(project,prefsid,path,list,selected);
  372.                                                                                             }
  373.                                                                                         else
  374.                                                                                             {
  375.                                                                                                 char s[256];
  376.                                                                                                 sprintf(s,"Unable to delete `%s/%s'.",path,node->ln_Name);
  377.                                                                                                 error_request(project,s);
  378.                                                                                             }
  379.                                                                                     }
  380.                                                                             }
  381.                                                                         break;
  382.                                                                     case 57: /* Move Up */
  383.                                                                         if(prefs_flags[prefsid] & PREFS_ListMode)
  384.                                                                             {
  385.                                                                                 struct Node *node;
  386.                                                                                 if(node=GetNode(list,selected))
  387.                                                                                     {
  388.                                                                                         if(SetConfigTags(
  389.                                                                                                 CFGTAG_Path,path,
  390.                                                                                                 CFGTAG_Name,node->ln_Name,
  391.                                                                                                 CFGTAG_MoveUp,TRUE,
  392.                                                                                                 CFGTAG_DontSave,TRUE,
  393.                                                                                                 TAG_END))
  394.                                                                                             {
  395.                                                                                                 BYTE name[33];
  396.                                                                                                 strcpy(name,node->ln_Name);
  397.                                                                                                 TR_SetAttribute(project,51,0,0);
  398.                                                                                                 DeleteList(list);
  399.                                                                                                 selected=0;
  400.                                                                                                 if(list=CreateList(path))
  401.                                                                                                     selected=GetNodeNum(list,name);
  402.                                                                                                 TR_SetAttribute(project,51,0,(ULONG) list);
  403.                                                                                                 TR_SetAttribute(project,51,TRAT_Value,selected);
  404.                                                                                                 update_gadgets(project,prefsid,path,list,selected);
  405.                                                                                             }
  406.                                                                                         else
  407.                                                                                             {
  408.                                                                                                 char s[256];
  409.                                                                                                 sprintf(s,"Unable to move `%s' up.",node->ln_Name);
  410.                                                                                                 error_request(project,s);
  411.                                                                                             }
  412.                                                                                     }
  413.                                                                             }
  414.                                                                         break;
  415.                                                                     case 58: /* Move Down */
  416.                                                                         if(prefs_flags[prefsid] & PREFS_ListMode)
  417.                                                                             {
  418.                                                                                 struct Node *node;
  419.                                                                                 if(node=GetNode(list,selected))
  420.                                                                                     {
  421.                                                                                         if(SetConfigTags(
  422.                                                                                                 CFGTAG_Path,path,
  423.                                                                                                 CFGTAG_Name,node->ln_Name,
  424.                                                                                                 CFGTAG_MoveDown,TRUE,
  425.                                                                                                 CFGTAG_DontSave,TRUE,
  426.                                                                                                 TAG_END))
  427.                                                                                             {
  428.                                                                                                 BYTE name[33];
  429.                                                                                                 strcpy(name,node->ln_Name);
  430.                                                                                                 TR_SetAttribute(project,51,0,0);
  431.                                                                                                 DeleteList(list);
  432.                                                                                                 selected=0;
  433.                                                                                                 if(list=CreateList(path))
  434.                                                                                                     selected=GetNodeNum(list,name);
  435.                                                                                                 TR_SetAttribute(project,51,0,(ULONG) list);
  436.                                                                                                 TR_SetAttribute(project,51,TRAT_Value,selected);
  437.                                                                                                 update_gadgets(project,prefsid,path,list,selected);
  438.                                                                                             }
  439.                                                                                         else
  440.                                                                                             {
  441.                                                                                                 char s[256];
  442.                                                                                                 sprintf(s,"Unable to move `%s' down.",node->ln_Name);
  443.                                                                                                 error_request(project,s);
  444.                                                                                             }
  445.                                                                                     }
  446.                                                                             }
  447.                                                                         break;
  448.                                                                     case 101: /* Quit */
  449.                                                                         kg=FALSE;
  450.                                                                         break;
  451.                                                                     default:
  452.                                                                         if(prefs_flags[prefsid] & PREFS_ListMode)
  453.                                                                             {
  454.                                                                                 struct Node *node;
  455.                                                                                 if(node=GetNode(list,selected))
  456.                                                                                     {
  457.                                                                                         if(process_prefs_gadgets(project,path,node->ln_Name,prefsid,msg->trm_ID,msg->trm_Data))
  458.                                                                                             update_gadgets(project,prefsid,path,list,selected);
  459.                                                                                     }
  460.                                                                             }
  461.                                                                         else
  462.                                                                             {
  463.                                                                                 if(process_prefs_gadgets(project,NULL,"System",prefsid,msg->trm_ID,msg->trm_Data))
  464.                                                                                     update_gadgets(project,prefsid,path,list,selected);
  465.                                                                             }
  466.                                                                         break;
  467.                                                                 }
  468.                                                             break;
  469.                                                         case TRMS_KEYPRESSED:
  470.                                                             switch(msg->trm_Code)
  471.                                                                 {
  472.                                                                     case 0x4f: /* left */
  473.                                                                         if(prefs_flags[prefsid] & PREFS_TreeMode)
  474.                                                                             {
  475.                                                                                 if(strchr(path,'/'))
  476.                                                                                     {
  477.                                                                                         char *p;
  478.                                                                                         if(p=PathPart(path))
  479.                                                                                             {
  480.                                                                                                 TR_SetAttribute(project,51,0,0);
  481.                                                                                                 DeleteList(list);
  482.                                                                                                 selected=0;
  483.                                                                                                 *p=NULL;
  484.                                                                                                 list=CreateList(path);
  485.                                                                                                 TR_SetAttribute(project,51,0,(ULONG) list);
  486.                                                                                                 TR_SetAttribute(project,51,TRAT_Value,selected);
  487.                                                                                                 update_gadgets(project,prefsid,path,list,selected);
  488.                                                                                             }
  489.                                                                                     }
  490.                                                                             }
  491.                                                                         break;
  492.                                                                     case 0x4e: /* right */
  493.                                                                         if(prefs_flags[prefsid] & PREFS_TreeMode)
  494.                                                                             {
  495.                                                                                 struct Node *node;
  496.                                                                                 if(node=GetNode(list,selected))
  497.                                                                                     {
  498.                                                                                         TR_SetAttribute(project,51,0,0);
  499.                                                                                         DeleteList(list);
  500.                                                                                         selected=0;
  501.                                                                                         if(!AddPart(path,node->ln_Name,511))
  502.                                                                                             {
  503.                                                                                                 char s[256];
  504.                                                                                                 sprintf(s,"Unable to enter `%s/%s'.",path,node->ln_Name);
  505.                                                                                                 error_request(project,s);
  506.                                                                                             }
  507.                                                                                         list=CreateList(path);
  508.                                                                                         TR_SetAttribute(project,51,0,(ULONG) list);
  509.                                                                                         TR_SetAttribute(project,51,TRAT_Value,selected);
  510.                                                                                         update_gadgets(project,prefsid,path,list,selected);
  511.                                                                                     }
  512.                                                                             }
  513.                                                                         break;
  514.                                                                 }
  515.                                                             break;
  516.                                                     }
  517.                                             }
  518.                                         TR_ReplyMsg(msg);
  519.                                     }
  520.                             }
  521.                         }
  522.                 }
  523.                 if(list)
  524.                     {
  525.                         TR_SetAttribute(project,51,0,NULL);
  526.                         DeleteList(list);
  527.                     }
  528.                 TR_CloseProject(project);
  529.             }
  530.         else
  531.             TR_EasyRequestTags(Application,TR_GetErrorString(TR_GetLastError(Application)),"Okay",TREZ_ReqPos,TRWP_CENTERDISPLAY,TREZ_Title,"World Wide BBS Error Request",TAG_END);
  532.     }
  533.  
  534. void error_request(struct TR_Project *project,BYTE *s)
  535.     {
  536.         TR_EasyRequestTags(Application,s,"Okay",TREZ_ReqPos,TRWP_CENTERDISPLAY,TREZ_LockProject,project,TREZ_Title,"World Wide BBS",TAG_END);
  537.     }
  538.  
  539. /***/
  540.  
  541. struct List *CreateList(BYTE *path)
  542.     {
  543.         struct List *list=NULL;
  544.         if(list=AllocVec(sizeof(struct List),MEMF_CLEAR))
  545.             {
  546.                 NewList(list);
  547.                 {
  548.                     ULONG next=0;
  549.                     STRPTR name;
  550.                     struct BufferNode *node;
  551.                     while(next=GetConfigTags(
  552.                             CFGTAG_Path,path,
  553.                             CFGTAG_Name,&name,
  554.                             CFGTAG_Next,next,
  555.                             TAG_END))
  556.                         {
  557.                             if(node=AllocVec(sizeof(struct BufferNode),MEMF_CLEAR))
  558.                                 {
  559.                                     strcpy(node->bn_Buffer,name);
  560.                                     node->bn_Node.ln_Name=node->bn_Buffer;
  561.                                     AddTail(list,(struct Node *) node);
  562.                                 }
  563.                         }
  564.                 }
  565.             }
  566.         return(list);
  567.     }
  568.  
  569. void DeleteList(struct List *list)
  570.     {
  571.         {
  572.             struct Node *node;
  573.             while(node=RemHead(list))
  574.                 FreeVec(node);
  575.         }
  576.         FreeVec(list);
  577.     }
  578.  
  579. struct Node *GetNode(struct List *list,ULONG num)
  580.     {
  581.         struct Node *node=NULL;
  582.         ULONG i;
  583.         if(list && list->lh_Head->ln_Succ)
  584.             {
  585.                 node=list->lh_Head;
  586.                 for(i=0;i<num;i++)
  587.                     {
  588.                         if(node->ln_Succ)
  589.                             node=node->ln_Succ;
  590.                     }
  591.             }
  592.         return(node);
  593.     }
  594.  
  595. ULONG GetNodeNum(struct List *list,BYTE *name)
  596.     {
  597.         ULONG ret=0;
  598.         if(list)
  599.             {
  600.                 struct Node *node=NULL,*searchnode=NULL;
  601.                 if(searchnode=FindName(list,name))
  602.                     {
  603.                         for(node=list->lh_Head;node->ln_Succ;node=node->ln_Succ)
  604.                             {
  605.                                 if(node==searchnode)
  606.                                     break;
  607.                                 ret++;
  608.                             }
  609.                     }
  610.             }
  611.         return(ret);
  612.     }
  613.  
  614. /***/
  615.  
  616. void update_gadgets(struct TR_Project *project,UWORD prefsid,BYTE *path,struct List *list,ULONG selected)
  617.     {
  618.         if(prefs_flags[prefsid] & PREFS_ListMode)
  619.             {
  620.                 struct Node *node;
  621.                 if(node=GetNode(list,selected))
  622.                     {
  623.                         update_gadget(project,52,node->ln_Name,node);
  624.                         TR_SetAttribute(project,56,TRAT_Disabled,FALSE);
  625.                         TR_SetAttribute(project,57,TRAT_Disabled,(selected==0) ? TRUE : FALSE);
  626.                         {
  627.                             struct Node *wn;
  628.                             wn=node->ln_Succ;
  629.                             TR_SetAttribute(project,58,TRAT_Disabled,(wn->ln_Succ) ? FALSE : TRUE);
  630.                         }
  631.                     }
  632.                 else
  633.                     {
  634.                         TR_SetAttribute(project,56,TRAT_Disabled,TRUE);
  635.                         TR_SetAttribute(project,57,TRAT_Disabled,TRUE);
  636.                         TR_SetAttribute(project,58,TRAT_Disabled,TRUE);
  637.                     }
  638.             }
  639.         if(prefs_flags[prefsid] & PREFS_TreeMode)
  640.             {
  641.                 TR_SetAttribute(project,59,TRAT_Text,NULL);
  642.                 {
  643.                     char *p;
  644.                     if(p=strchr(path,'/'))
  645.                         {
  646.                             p++;
  647.                             if(strlen(p)>32)
  648.                                 sprintf(path_buff,"...%.29s",&p[strlen(p)-29]);
  649.                             else
  650.                                 strcpy(path_buff,p);
  651.                             TR_SetAttribute(project,59,TRAT_Text,(ULONG) path_buff);
  652.                         }
  653.                 }
  654.                 TR_SetAttribute(project,53,TRAT_Disabled,(strchr(path,'/')) ? FALSE : TRUE);
  655.                 TR_SetAttribute(project,54,TRAT_Disabled,(list->lh_Head->ln_Succ) ? FALSE : TRUE);
  656.             }
  657.         {
  658.             struct Node *node=NULL;
  659.             node=GetNode(list,selected);
  660.             switch(prefsid)
  661.                 {
  662.                     case 0: /* Access Groups */
  663.                         {
  664.                             ULONG days=0;
  665.                             UWORD sessiontimelimit=0,inactivitytimelimit=0;
  666.                             UBYTE accesslevel=0,ratiobyte=0,ratiofile=0;
  667.                             if(node)
  668.                                 {
  669.                                     GetConfigTags(
  670.                                         CFGTAG_Path,path,
  671.                                         CFGTAG_Name,node->ln_Name,
  672.                                         AGTAG_AccessLevel,&accesslevel,
  673.                                         AGTAG_SessionTimeLimit,&sessiontimelimit,
  674.                                         AGTAG_InactivityTimeLimit,&inactivitytimelimit,
  675.                                         AGTAG_RatioByte,&ratiobyte,
  676.                                         AGTAG_RatioFile,&ratiofile,
  677.                                         AGTAG_Days,&days,
  678.                                         TAG_END);
  679.                                 }
  680.                             update_integer_gadget(project,1,ag_accesslevel_buff,accesslevel,node);
  681.                             update_integer_gadget(project,2,ag_sessiontimelimit_buff,sessiontimelimit,node);
  682.                             update_integer_gadget(project,3,ag_inactivitytimelimit_buff,inactivitytimelimit,node);
  683.                             update_integer_gadget(project,4,ag_ratiobyte_buff,ratiobyte,node);
  684.                             update_integer_gadget(project,5,ag_ratiofile_buff,ratiofile,node);
  685.                             update_integer_gadget(project,6,ag_days_buff,days,node);
  686.                         }
  687.                         break;
  688.                     case 1: /* Archivers */
  689.                         {
  690.                             strcpy(arc_extension,"");
  691.                             strcpy(arc_addcommand,"");
  692.                             strcpy(arc_extractcommand,"");
  693.                             strcpy(arc_viewcommand,"");
  694.                             if(node)
  695.                                 {
  696.                                     GetConfigTags(
  697.                                         CFGTAG_Path,path,
  698.                                         CFGTAG_Name,node->ln_Name,
  699.                                         ARCTAG_Extension,arc_extension,
  700.                                         ARCTAG_AddCommand,arc_addcommand,
  701.                                         ARCTAG_ExtractCommand,arc_extractcommand,
  702.                                         ARCTAG_ViewCommand,arc_viewcommand,
  703.                                         TAG_END);
  704.                                 }
  705.                             update_gadget(project,1,arc_extension,node);
  706.                             update_gadget(project,2,arc_addcommand,node);
  707.                             update_gadget(project,3,arc_extractcommand,node);
  708.                             update_gadget(project,4,arc_viewcommand,node);
  709.                         }
  710.                         break;
  711.                     case 2: /* Editors */
  712.                         {
  713.                             UBYTE type=0;
  714.                             ULONG stack=0;
  715.                             strcpy(ed_command,"");
  716.                             if(node)
  717.                                 {
  718.                                     GetConfigTags(
  719.                                         CFGTAG_Path,path,
  720.                                         CFGTAG_Name,node->ln_Name,
  721.                                         EDTAG_Type,&type,
  722.                                         EDTAG_Command,ed_command,
  723.                                         EDTAG_Stack,&stack,
  724.                                         TAG_END);
  725.                                 }
  726.                             update_cycle_gadget(project,1,type,node);
  727.                             update_gadget(project,2,ed_command,node);
  728.                             TR_SetAttribute(project,3,TRAT_Disabled,(node) ? FALSE : TRUE);
  729.                             update_integer_gadget(project,4,ed_stack_buff,stack,node);
  730.                         }
  731.                         break;
  732.                     case 3: /* File Bases */
  733.                         {
  734.                             ULONG diskspacerequired=0,days=0;
  735.                             BOOL readonly=FALSE,autojoin=FALSE;
  736.                             strcpy(fb_accessrange,"");
  737.                             strcpy(fb_group,"");
  738.                             strcpy(fb_directory,"");
  739.                             if(node)
  740.                                 {
  741.                                     GetConfigTags(
  742.                                         CFGTAG_Path,path,
  743.                                         CFGTAG_Name,node->ln_Name,
  744.                                         FBTAG_AccessRange,fb_accessrange,
  745.                                         FBTAG_Group,fb_group,
  746.                                         FBTAG_Directory,fb_directory,
  747.                                         FBTAG_DiskSpaceRequired,&diskspacerequired,
  748.                                         FBTAG_Days,&days,
  749.                                         FBTAG_ReadOnly,&readonly,
  750.                                         FBTAG_AutoJoin,&autojoin,
  751.                                         TAG_END);
  752.                                 }
  753.                             update_gadget(project,1,fb_accessrange,node);
  754.                             update_gadget(project,2,fb_group,node);
  755.                             update_gadget(project,3,fb_directory,node);
  756.                             TR_SetAttribute(project,4,TRAT_Disabled,(node) ? FALSE : TRUE);
  757.                             update_integer_gadget(project,5,fb_diskspacerequired,diskspacerequired,node);
  758.                             update_integer_gadget(project,6,fb_days,days,node);
  759.                             update_checkbox_gadget(project,7,readonly,node);
  760.                             update_checkbox_gadget(project,8,autojoin,node);
  761.                         }
  762.                         break;
  763.                     case 4: /* Menus */
  764.                         {
  765.                             BOOL child=FALSE;
  766.                             BYTE character=0,defaultchar=0,number=0;
  767.                             strcpy(mn_accessrange,"");
  768.                             strcpy(mn_prompt,"");
  769.                             strcpy(mn_command,"");
  770.                             if(node)
  771.                                 {
  772.                                     GetConfigTags(
  773.                                         CFGTAG_Path,path,
  774.                                         CFGTAG_Name,node->ln_Name,
  775.                                         CFGTAG_Child,&child,
  776.                                         MNTAG_AccessRange,mn_accessrange,
  777.                                         MNTAG_Character,&character,
  778.                                         MNTAG_Default,&defaultchar,
  779.                                         MNTAG_Number,&number,
  780.                                         MNTAG_Prompt,mn_prompt,
  781.                                         MNTAG_Command,mn_command,
  782.                                         TAG_END);
  783.                                 }
  784.                             update_gadget(project,1,mn_accessrange,node);
  785.                             sprintf(mn_character,"%c",character);
  786.                             update_gadget(project,2,mn_character,node);
  787.                             if(child)
  788.                                 {
  789.                                     sprintf(mn_defaultchar,"%c",defaultchar);
  790.                                     update_gadget(project,3,mn_defaultchar,node);
  791.                                     sprintf(mn_number,"%c",number);
  792.                                     update_gadget(project,4,mn_number,node);
  793.                                     update_gadget(project,5,mn_prompt,node);
  794.                                     TR_SetAttribute(project,6,TRAT_Disabled,TRUE);
  795.                                 }
  796.                             else
  797.                                 {
  798.                                     update_gadget(project,3,NULL,FALSE);
  799.                                     update_gadget(project,4,NULL,FALSE);
  800.                                     update_gadget(project,5,NULL,FALSE);
  801.                                     update_gadget(project,6,mn_command,node);
  802.                                 }
  803.                         }
  804.                         break;
  805.                     case 5: /* Message Bases */
  806.                         {
  807.                             ULONG days=0;
  808.                             BOOL readonly=FALSE,autojoin=FALSE;
  809.                             strcpy(mb_accessrange,"");
  810.                             strcpy(mb_group,"");
  811.                             strcpy(mb_quoteheader,"");
  812.                             if(node)
  813.                                 {
  814.                                     GetConfigTags(
  815.                                         CFGTAG_Path,path,
  816.                                         CFGTAG_Name,node->ln_Name,
  817.                                         MBTAG_AccessRange,mb_accessrange,
  818.                                         MBTAG_Group,mb_group,
  819.                                         MBTAG_QuoteHeader,mb_quoteheader,
  820.                                         MBTAG_Days,&days,
  821.                                         MBTAG_ReadOnly,&readonly,
  822.                                         MBTAG_AutoJoin,&autojoin,
  823.                                         TAG_END);
  824.                                 }
  825.                             update_gadget(project,1,mb_accessrange,node);
  826.                             update_gadget(project,2,mb_group,node);
  827.                             update_gadget(project,3,mb_quoteheader,node);
  828.                             update_checkbox_gadget(project,4,readonly,node);
  829.                             update_checkbox_gadget(project,5,autojoin,node);
  830.                             update_integer_gadget(project,6,mb_days,days,node);
  831.                         }
  832.                         break;
  833.                     case 6: /* News */
  834.                         {
  835.                             strcpy(nws_accessrange,"");
  836.                             strcpy(nws_file,"");
  837.                             if(node)
  838.                                 {
  839.                                     GetConfigTags(
  840.                                         CFGTAG_Path,path,
  841.                                         CFGTAG_Name,node->ln_Name,
  842.                                         NWSTAG_AccessRange,nws_accessrange,
  843.                                         NWSTAG_File,nws_file,
  844.                                         TAG_END);
  845.                                 }
  846.                             update_gadget(project,1,nws_accessrange,node);
  847.                             update_gadget(project,2,nws_file,node);
  848.                             TR_SetAttribute(project,3,TRAT_Disabled,(node) ? FALSE : TRUE);
  849.                             if(node)
  850.                                 {
  851.                                     struct DateStamp ds={0};
  852.                                     if(strlen(nws_file))
  853.                                         {
  854.                                             BPTR fh;
  855.                                             if(fh=Open(nws_file,MODE_OLDFILE))
  856.                                                 {
  857.                                                     __aligned struct FileInfoBlock fib;
  858.                                                     if(ExamineFH(fh,&fib))
  859.                                                         ds=fib.fib_Date;
  860.                                                     Close(fh);
  861.                                                 }
  862.                                         }
  863.                                     update_text_gadget(project,4,NULL,TRUE);
  864.                                     if(ds.ds_Days || ds.ds_Minute  || ds.ds_Tick)
  865.                                         {
  866.                                             {
  867.                                                 struct DateTime dt;
  868.                                                 char strdate[32],strtime[32];
  869.                                                 dt.dat_Stamp=ds;
  870.                                                 dt.dat_Format=FORMAT_USA;
  871.                                                 dt.dat_Flags=DTF_SUBST;
  872.                                                 dt.dat_StrDay=NULL;
  873.                                                 dt.dat_StrDate=strdate;
  874.                                                 dt.dat_StrTime=strtime;
  875.                                                 DateToStr(&dt);
  876.                                                 sprintf(date_buff,"%s %s",strdate,strtime);
  877.                                             }
  878.                                             update_text_gadget(project,4,date_buff,TRUE);
  879.                                         }
  880.                                 }
  881.                             else
  882.                                 update_text_gadget(project,4,0,FALSE);
  883.                         }
  884.                         break;
  885.                     case 7: /* Nodes */
  886.                         {
  887.                             UBYTE type=0;
  888.                             ULONG unit=0,buffersize=0,baud=0;
  889.                             BOOL handshaking=FALSE,autobaud=FALSE,frontend=FALSE;
  890.                             strcpy(nd_accessrange,"");
  891.                             strcpy(nd_device,"");
  892.                             strcpy(nd_command,"");
  893.                             if(node)
  894.                                 {
  895.                                     GetConfigTags(
  896.                                         CFGTAG_Path,path,
  897.                                         CFGTAG_Name,node->ln_Name,
  898.                                         NDTAG_AccessRange,nd_accessrange,
  899.                                         NDTAG_Type,&type,
  900.                                         NDTAG_Device,nd_device,
  901.                                         NDTAG_Unit,&unit,
  902.                                         NDTAG_BufferSize,&buffersize,
  903.                                         NDTAG_Baud,&baud,
  904.                                         NDTAG_Handshaking,&handshaking,
  905.                                         NDTAG_AutoBaud,&autobaud,
  906.                                         NDTAG_FrontEnd,&frontend,
  907.                                         NDTAG_Command,nd_command,
  908.                                         TAG_END);
  909.                                 }
  910.                             update_gadget(project,1,nd_accessrange,node);
  911.                             update_cycle_gadget(project,2,type,node);
  912.                             update_gadget(project,3,nd_device,node);
  913.                             TR_SetAttribute(project,4,TRAT_Disabled,(node) ? FALSE : TRUE);
  914.                             update_integer_gadget(project,5,nd_unit,unit,node);
  915.                             update_integer_gadget(project,6,nd_buffersize,buffersize,node);
  916.                             update_integer_gadget(project,7,nd_baud,baud,node);
  917.                             update_checkbox_gadget(project,8,handshaking,node);
  918.                             update_checkbox_gadget(project,9,autobaud,node);
  919.                             update_checkbox_gadget(project,10,frontend,node);
  920.                             update_gadget(project,11,nd_command,node);
  921.                         }
  922.                         break;
  923.                     case 8: /* Protocols */
  924.                         {
  925.                             BOOL batch=FALSE,bidirectional=FALSE;
  926.                             strcpy(pr_sendcommand,"");
  927.                             strcpy(pr_receivecommand,"");
  928.                             if(node)
  929.                                 {
  930.                                     GetConfigTags(
  931.                                         CFGTAG_Path,path,
  932.                                         CFGTAG_Name,node->ln_Name,
  933.                                         PRTAG_SendCommand,pr_sendcommand,
  934.                                         PRTAG_ReceiveCommand,pr_receivecommand,
  935.                                         PRTAG_Batch,&batch,
  936.                                         PRTAG_Bidirectional,&bidirectional,
  937.                                         TAG_END);
  938.                                 }
  939.                             update_gadget(project,1,pr_sendcommand,node);
  940.                             update_gadget(project,2,pr_receivecommand,node);
  941.                             update_checkbox_gadget(project,3,batch,node);
  942.                             update_checkbox_gadget(project,4,bidirectional,node);
  943.                         }
  944.                         break;
  945.                     case 9: /* System */
  946.                         {
  947.                             BOOL onlyrealnames=FALSE;
  948.                             strcpy(sys_inputcolor,"");
  949.                             strcpy(sys_headercolor,"");
  950.                             strcpy(sys_outputcolor,"");
  951.                             strcpy(sys_promptcolor,"");
  952.                             strcpy(sys_systemcolor,"");
  953.                             strcpy(sys_fileiddizextractor,"");
  954.                             GetConfigTags(
  955.                                 CFGTAG_Name,"System",
  956.                                 SYSTAG_InputColor,sys_inputcolor,
  957.                                 SYSTAG_HeaderColor,sys_headercolor,
  958.                                 SYSTAG_OutputColor,sys_outputcolor,
  959.                                 SYSTAG_PromptColor,sys_promptcolor,
  960.                                 SYSTAG_SystemColor,sys_systemcolor,
  961.                                 SYSTAG_FileIDDizExtractor,sys_fileiddizextractor,
  962.                                 SYSTAG_OnlyRealNames,&onlyrealnames,
  963.                                 TAG_END);
  964.                             TR_SetAttribute(project,5,0,(ULONG)sys_headercolor);
  965.                             TR_SetAttribute(project,6,0,(ULONG)sys_inputcolor);
  966.                             TR_SetAttribute(project,7,0,(ULONG)sys_outputcolor);
  967.                             TR_SetAttribute(project,8,0,(ULONG)sys_promptcolor);
  968.                             TR_SetAttribute(project,9,0,(ULONG)sys_systemcolor);
  969.                             TR_SetAttribute(project,12,0,(ULONG)sys_fileiddizextractor);
  970.                             TR_SetAttribute(project,11,TRAT_Value,(ULONG)onlyrealnames);
  971.                         }
  972.                         break;
  973.                 }
  974.         }
  975.     }
  976.  
  977. BOOL process_prefs_gadgets(struct TR_Project *project,BYTE *path,BYTE *name,UWORD prefsid,ULONG id,ULONG data)
  978.     {
  979.         BOOL ret=FALSE;
  980.         switch(prefsid)
  981.             {
  982.                 case 0: /* Access Groups */
  983.                     switch(id)
  984.                         {
  985.                             case 1:
  986.                                 set_config(AGTAG_AccessLevel,atol((STRPTR) data));
  987.                                 break;
  988.                             case 2:
  989.                                 set_config(AGTAG_SessionTimeLimit,atol((STRPTR) data));
  990.                                 break;
  991.                             case 3:
  992.                                 set_config(AGTAG_InactivityTimeLimit,atol((STRPTR) data));
  993.                                 break;
  994.                             case 4:
  995.                                 set_config(AGTAG_RatioByte,atol((STRPTR) data));
  996.                                 break;
  997.                             case 5:
  998.                                 set_config(AGTAG_RatioFile,atol((STRPTR) data));
  999.                                 break;
  1000.                             case 6:
  1001.                                 set_config(AGTAG_Days,atol((STRPTR) data));
  1002.                                 break;
  1003.                         }
  1004.                     break;
  1005.                 case 1: /* Archivers */
  1006.                     switch(id)
  1007.                         {
  1008.                             case 1:
  1009.                                 set_config(ARCTAG_Extension,data);
  1010.                                 break;
  1011.                             case 2:
  1012.                                 set_config(ARCTAG_AddCommand,data);
  1013.                                 break;
  1014.                             case 3:
  1015.                                 set_config(ARCTAG_ExtractCommand,data);
  1016.                                 break;
  1017.                             case 4:
  1018.                                 set_config(ARCTAG_ViewCommand,data);
  1019.                                 break;
  1020.                         }
  1021.                     break;
  1022.                 case 2: /* Editors */
  1023.                     switch(id)
  1024.                         {
  1025.                             case 1:
  1026.                                 set_config(EDTAG_Type,data);
  1027.                                 break;
  1028.                             case 2:
  1029.                                 set_config(EDTAG_Command,data);
  1030.                                 break;
  1031.                             case 3:
  1032.                                 {
  1033.                                     BYTE file[256],*p;
  1034.                                     p=(BYTE *) TR_GetAttribute(project,2,0);
  1035.                                     if(asl_file_requester(project,"Select Editor...",(p) ? p : "",NULL,file))
  1036.                                         {
  1037.                                             set_config(EDTAG_Command,file);
  1038.                                             TR_SetAttribute(project,2,0,(ULONG) file);
  1039.                                         }
  1040.                                 }
  1041.                                 break;
  1042.                             case 4:
  1043.                                 set_config(EDTAG_Stack,atol((STRPTR) data));
  1044.                                 break;
  1045.                         }
  1046.                     break;
  1047.                 case 3: /* File Bases */
  1048.                     switch(id)
  1049.                         {
  1050.                             case 1:
  1051.                                 ret=(set_config(FBTAG_AccessRange,data)) ? FALSE : TRUE;
  1052.                                 break;
  1053.                             case 2:
  1054.                                 ret=(set_config(FBTAG_Group,data)) ? FALSE : TRUE;
  1055.                                 break;
  1056.                             case 3:
  1057.                                 if(set_config(FBTAG_Directory,data))
  1058.                                     {
  1059.                                         if(strlen((STRPTR) data))
  1060.                                             mkdir((STRPTR) data);
  1061.                                     }
  1062.                                 else
  1063.                                     ret=TRUE;
  1064.                                 break;
  1065.                             case 4:
  1066.                                 {
  1067.                                     BYTE dir[256],*p;
  1068.                                     p=(BYTE *) TR_GetAttribute(project,3,0);
  1069.                                     if(asl_drawer_requester(project,"Select Directory...",(p) ? p : "",dir))
  1070.                                         {
  1071.                                             if(set_config(FBTAG_Directory,dir))
  1072.                                                 {
  1073.                                                     TR_SetAttribute(project,3,0,(ULONG) dir);
  1074.                                                     if(strlen(dir))
  1075.                                                         mkdir(dir);
  1076.                                                 }
  1077.                                             else
  1078.                                                 ret=TRUE;
  1079.                                         }
  1080.                                 }
  1081.                                 break;
  1082.                             case 5:
  1083.                                 ret=(set_config(FBTAG_DiskSpaceRequired,atol((STRPTR) data))) ? FALSE : TRUE;
  1084.                                 break;
  1085.                             case 6:
  1086.                                 ret=(set_config(FBTAG_Days,atol((STRPTR) data))) ? FALSE : TRUE;
  1087.                                 break;
  1088.                             case 7:
  1089.                                 ret=(set_config(FBTAG_ReadOnly,data)) ? FALSE : TRUE;
  1090.                                 break;
  1091.                             case 8:
  1092.                                 ret=(set_config(FBTAG_AutoJoin,data)) ? FALSE : TRUE;
  1093.                                 break;
  1094.                         }
  1095.                     break;
  1096.                 case 4: /* Menus */
  1097.                     switch(id)
  1098.                         {
  1099.                             case 1:
  1100.                                 set_config(MNTAG_AccessRange,data);
  1101.                                 break;
  1102.                             case 2:
  1103.                                 {
  1104.                                     BOOL ok=FALSE;
  1105.                                     if(((STRPTR) data)[0])
  1106.                                         {
  1107.                                             BOOL inuse=FALSE;
  1108.                                             BYTE *temp_name=NULL;
  1109.                                             BYTE c=NULL;
  1110.                                             {
  1111.                                                 ULONG next=NULL;
  1112.                                                 while(next=GetConfigTags(CFGTAG_Path,path,
  1113.                                                         CFGTAG_Name,&temp_name,
  1114.                                                         CFGTAG_Next,next,
  1115.                                                         MNTAG_Character,&c,
  1116.                                                         TAG_END))
  1117.                                                     {
  1118.                                                         if(toupper(((STRPTR) data)[0])==toupper(c))
  1119.                                                             {
  1120.                                                                 if(stricmp(temp_name,name))
  1121.                                                                     inuse=TRUE;
  1122.                                                             }
  1123.                                                     }
  1124.                                             }
  1125.                                             if(!inuse)
  1126.                                                 ok=TRUE;
  1127.                                         }
  1128.                                     else
  1129.                                         ok=TRUE;
  1130.                                     if(ok)
  1131.                                         {
  1132.                                             SetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,CFGTAG_DontSave,TRUE,
  1133.                                                 MNTAG_Character,toupper(((STRPTR) data)[0]),
  1134.                                                 TAG_END);
  1135.                                             {
  1136.                                                 char s[2];
  1137.                                                 sprintf(s,"%c",toupper(((STRPTR) data)[0]));
  1138.                                                 TR_SetAttribute(project,id,0,(ULONG) s);
  1139.                                             }
  1140.                                         }
  1141.                                     else
  1142.                                         {
  1143.                                             if(data && ((STRPTR) data)[0])
  1144.                                                 {
  1145.                                                     char s[256];
  1146.                                                     sprintf(s,"Character `%c' is in use.",toupper(((STRPTR) data)[0]));
  1147.                                                     error_request(project,s);
  1148.                                                 }
  1149.                                             {
  1150.                                                 BYTE c=NULL,s[2];
  1151.                                                 GetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,MNTAG_Character,&c,TAG_END);
  1152.                                                 sprintf(s,"%c",toupper(c));
  1153.                                                 TR_SetAttribute(project,id,0,(ULONG) s);
  1154.                                             }
  1155.                                         }
  1156.                                 }
  1157.                                 break;
  1158.                             case 3:
  1159.                                 SetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,CFGTAG_DontSave,TRUE,
  1160.                                     MNTAG_Default,toupper(((STRPTR) data)[0]),
  1161.                                     TAG_END);
  1162.                                 {
  1163.                                     char s[2];
  1164.                                     sprintf(s,"%c",toupper(((STRPTR) data)[0]));
  1165.                                     TR_SetAttribute(project,id,0,(ULONG) s);
  1166.                                 }
  1167.                                 break;
  1168.                             case 4:
  1169.                                 SetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,CFGTAG_DontSave,TRUE,
  1170.                                     MNTAG_Number,toupper(((STRPTR) data)[0]),
  1171.                                     TAG_END);
  1172.                                 {
  1173.                                     char s[2];
  1174.                                     sprintf(s,"%c",toupper(((STRPTR) data)[0]));
  1175.                                     TR_SetAttribute(project,id,0,(ULONG) s);
  1176.                                 }
  1177.                                 break;
  1178.                             case 5:
  1179.                                 set_config(MNTAG_Prompt,data);
  1180.                                 break;
  1181.                             case 6:
  1182.                                 set_config(MNTAG_Command,data);
  1183.                                 break;
  1184.                         }
  1185.                     break;
  1186.                 case 5: /* Message Bases */
  1187.                     switch(id)
  1188.                         {
  1189.                             case 1:
  1190.                                 set_config(MBTAG_AccessRange,data);
  1191.                                 break;
  1192.                             case 2:
  1193.                                 if(!strchr((STRPTR) data,' '))
  1194.                                     set_config(MBTAG_Group,data);
  1195.                                 else
  1196.                                     error_request(project,"Spaces are not allowed.");
  1197.                                 break;
  1198.                             case 3:
  1199.                                 set_config(MBTAG_QuoteHeader,data);
  1200.                                 break;
  1201.                             case 4:
  1202.                                 set_config(MBTAG_ReadOnly,data);
  1203.                                 break;
  1204.                             case 5:
  1205.                                 set_config(MBTAG_AutoJoin,data);
  1206.                                 break;
  1207.                             case 6:
  1208.                                 set_config(MBTAG_Days,atol((STRPTR) data));
  1209.                                 break;
  1210.                         }
  1211.                     break;
  1212.                 case 6: /* News */
  1213.                     switch(id)
  1214.                         {
  1215.                             case 1:
  1216.                                 set_config(NWSTAG_AccessRange,data);
  1217.                                 break;
  1218.                             case 2:
  1219.                                 set_config(NWSTAG_File,data);
  1220.                                 {
  1221.                                     struct DateStamp ds={0};
  1222.                                     {
  1223.                                         BPTR fh;
  1224.                                         if(fh=Open((STRPTR) data,MODE_OLDFILE))
  1225.                                             {
  1226.                                                 __aligned struct FileInfoBlock fib;
  1227.                                                 if(ExamineFH(fh,&fib))
  1228.                                                     ds=fib.fib_Date;
  1229.                                                 Close(fh);
  1230.                                             }
  1231.                                     }
  1232.                                     if(ds.ds_Days || ds.ds_Minute  || ds.ds_Tick)
  1233.                                         {
  1234.                                             {
  1235.                                                 TR_SetAttribute(project,4,TRAT_Text,NULL);
  1236.                                                 {
  1237.                                                     struct DateTime dt;
  1238.                                                     char strdate[32],strtime[32];
  1239.                                                     dt.dat_Stamp=ds;
  1240.                                                     dt.dat_Format=FORMAT_USA;
  1241.                                                     dt.dat_Flags=DTF_SUBST;
  1242.                                                     dt.dat_StrDay=NULL;
  1243.                                                     dt.dat_StrDate=strdate;
  1244.                                                     dt.dat_StrTime=strtime;
  1245.                                                     DateToStr(&dt);
  1246.                                                     sprintf(date_buff,"%s %s",strdate,strtime);
  1247.                                                 }
  1248.                                                 TR_SetAttribute(project,4,TRAT_Text,(ULONG) date_buff);
  1249.                                                 TR_SetAttribute(project,4,TRAT_Disabled,FALSE);
  1250.                                             }
  1251.                                         }
  1252.                                 }
  1253.                                 break;
  1254.                             case 3:
  1255.                                 {
  1256.                                     BYTE file[256],*p;
  1257.                                     p=(BYTE *) TR_GetAttribute(project,2,0);
  1258.                                     if(asl_file_requester(project,"Select File...",(p) ? p : "",NULL,file))
  1259.                                         {
  1260.                                             set_config(NWSTAG_File,file);
  1261.                                             TR_SetAttribute(project,2,0,(ULONG) file);
  1262.                                             {
  1263.                                                 struct DateStamp ds={0};
  1264.                                                 {
  1265.                                                     BPTR fh;
  1266.                                                     if(fh=Open((STRPTR) file,MODE_OLDFILE))
  1267.                                                         {
  1268.                                                             __aligned struct FileInfoBlock fib;
  1269.                                                             if(ExamineFH(fh,&fib))
  1270.                                                                 ds=fib.fib_Date;
  1271.                                                             Close(fh);
  1272.                                                         }
  1273.                                                 }
  1274.                                                 if(ds.ds_Days || ds.ds_Minute  || ds.ds_Tick)
  1275.                                                     {
  1276.                                                         {
  1277.                                                             TR_SetAttribute(project,4,TRAT_Text,NULL);
  1278.                                                             {
  1279.                                                                 struct DateTime dt;
  1280.                                                                 char strdate[32],strtime[32];
  1281.                                                                 dt.dat_Stamp=ds;
  1282.                                                                 dt.dat_Format=FORMAT_USA;
  1283.                                                                 dt.dat_Flags=DTF_SUBST;
  1284.                                                                 dt.dat_StrDay=NULL;
  1285.                                                                 dt.dat_StrDate=strdate;
  1286.                                                                 dt.dat_StrTime=strtime;
  1287.                                                                 DateToStr(&dt);
  1288.                                                                 sprintf(date_buff,"%s %s",strdate,strtime);
  1289.                                                             }
  1290.                                                             TR_SetAttribute(project,4,TRAT_Text,(ULONG) date_buff);
  1291.                                                             TR_SetAttribute(project,4,TRAT_Disabled,FALSE);
  1292.                                                         }
  1293.                                                     }
  1294.                                             }
  1295.                                         }
  1296.                                 }
  1297.                                 break;
  1298.                             case 4:
  1299.                                 break;
  1300.                         }
  1301.                     break;
  1302.                 case 7: /* Nodes */
  1303.                     switch(id)
  1304.                         {
  1305.                             case 1:
  1306.                                 set_config(NDTAG_AccessRange,data);
  1307.                                 break;
  1308.                             case 2:
  1309.                                 set_config(NDTAG_Type,data);
  1310.                                 break;
  1311.                             case 3:
  1312.                                 set_config(NDTAG_Device,data);
  1313.                                 break;
  1314.                             case 4:
  1315.                                 {
  1316.                                     BYTE file[256],buff[256],*p;
  1317.                                     p=(BYTE *) TR_GetAttribute(project,3,0);
  1318.                                     strcpy(buff,"DEVS:");
  1319.                                     if(p)
  1320.                                         AddPart(buff,p,255);
  1321.                                     if(asl_file_requester(project,"Select Device...",buff,"#?.device",file))
  1322.                                         {
  1323.                                             set_config(NDTAG_Device,FilePart(file));
  1324.                                             TR_SetAttribute(project,3,0,(ULONG) FilePart(file));
  1325.                                         }
  1326.                                 }
  1327.                                 break;
  1328.                             case 5:
  1329.                                 set_config(NDTAG_Unit,atol((STRPTR) data));
  1330.                                 break;
  1331.                             case 6:
  1332.                                 set_config(NDTAG_BufferSize,atol((STRPTR) data));
  1333.                                 break;
  1334.                             case 7:
  1335.                                 set_config(NDTAG_Baud,atol((STRPTR) data));
  1336.                                 break;
  1337.                             case 8:
  1338.                                 set_config(NDTAG_Handshaking,data);
  1339.                                 break;
  1340.                             case 9:
  1341.                                 set_config(NDTAG_AutoBaud,data);
  1342.                                 break;
  1343.                             case 10:
  1344.                                 set_config(NDTAG_FrontEnd,data);
  1345.                                 break;
  1346.                             case 11:
  1347.                                 set_config(NDTAG_Command,data);
  1348.                                 break;
  1349.                         }
  1350.                     break;
  1351.                 case 8: /* Protocols */
  1352.                     switch(id)
  1353.                         {
  1354.                             case 1:
  1355.                                 set_config(PRTAG_SendCommand,data);
  1356.                                 break;
  1357.                             case 2:
  1358.                                 set_config(PRTAG_ReceiveCommand,data);
  1359.                                 break;
  1360.                             case 3:
  1361.                                 set_config(PRTAG_Batch,data);
  1362.                                 break;
  1363.                             case 4:
  1364.                                 set_config(PRTAG_Bidirectional,data);
  1365.                                 break;
  1366.                         }
  1367.                     break;
  1368.                 case 9: /* System */
  1369.                     switch(id)
  1370.                         {
  1371.                             case 5:
  1372.                                 set_config(SYSTAG_HeaderColor,data);
  1373.                                 break;
  1374.                             case 6:
  1375.                                 set_config(SYSTAG_InputColor,data);
  1376.                                 break;
  1377.                             case 7:
  1378.                                 set_config(SYSTAG_OutputColor,data);
  1379.                                 break;
  1380.                             case 8:
  1381.                                 set_config(SYSTAG_PromptColor,data);
  1382.                                 break;
  1383.                             case 9:
  1384.                                 set_config(SYSTAG_SystemColor,data);
  1385.                                 break;
  1386.                             case 11:
  1387.                                 set_config(SYSTAG_OnlyRealNames,data);
  1388.                                 break;
  1389.                             case 12:
  1390.                                 set_config(SYSTAG_FileIDDizExtractor,data);
  1391.                                 break;
  1392.                         }
  1393.                     break;
  1394.             }
  1395.         return(ret);
  1396.     }
  1397.  
  1398. BOOL asl_file_requester(struct TR_Project *project,BYTE *title,BYTE *file,BYTE *pattern,BYTE *result)
  1399.     {
  1400.         BOOL ret=FALSE;
  1401.         {
  1402.             struct FileRequester *fr;
  1403.             char dir[256];
  1404.             {
  1405.                 strcpy(dir,"");
  1406.                 {
  1407.                     char *p;
  1408.                     if(p=PathPart(file))
  1409.                         sprintf(dir,"%.*s",p-file,file);
  1410.                 }
  1411.             }
  1412.             if(fr=(struct FileRequester *) AllocAslRequestTags(ASL_FileRequest,
  1413.                     ASLFR_TitleText,title,
  1414.                     ASLFR_InitialDrawer,dir,
  1415.                     ASLFR_InitialFile,FilePart(file),
  1416.                     ASLFR_InitialPattern,(pattern) ? pattern : "#?",
  1417.                     ASLFR_FilterDrawers,TRUE,
  1418.                     TAG_END))
  1419.                 {
  1420.                     TR_LockProject(project);
  1421.                     if(AslRequestTags(fr,TAG_END))
  1422.                         {
  1423.                             strcpy(result,fr->fr_Drawer);
  1424.                             AddPart(result,fr->fr_File,255);
  1425.                             ret=TRUE;
  1426.                         }
  1427.                     TR_UnlockProject(project);
  1428.                     FreeAslRequest(fr);
  1429.                 }
  1430.         }
  1431.         return(ret);
  1432.     }
  1433.  
  1434. BOOL asl_drawer_requester(struct TR_Project *project,BYTE *title,BYTE *drawer,BYTE *result)
  1435.     {
  1436.         BOOL ret=FALSE;
  1437.         {
  1438.             struct FileRequester *fr;
  1439.             if(fr=(struct FileRequester *) AllocAslRequestTags(ASL_FileRequest,
  1440.                     ASLFR_TitleText,title,
  1441.                     ASLFR_InitialDrawer,drawer,
  1442.                     ASLFR_DrawersOnly,TRUE,
  1443.                     TAG_END))
  1444.                 {
  1445.                     TR_LockProject(project);
  1446.                     if(AslRequestTags(fr,TAG_END))
  1447.                         {
  1448.                             strcpy(result,fr->fr_Drawer);
  1449.                             ret=TRUE;
  1450.                         }
  1451.                     TR_UnlockProject(project);
  1452.                     FreeAslRequest(fr);
  1453.                 }
  1454.         }
  1455.         return(ret);
  1456.     }
  1457.  
  1458. void set_defaults(BYTE *path,BYTE *name,UWORD prefsid)
  1459.     {
  1460.         switch(prefsid)
  1461.             {
  1462.                 case 0: /* Access Groups */
  1463.                     break;
  1464.                 case 1: /* Archivers */
  1465.                     break;
  1466.                 case 2: /* Editors */
  1467.                     SetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,CFGTAG_DontSave,TRUE,
  1468.                         EDTAG_Stack,4096,TAG_END);
  1469.                     break;
  1470.                 case 3: /* File Bases */
  1471.                     SetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,CFGTAG_DontSave,TRUE,
  1472.                         FBTAG_AccessRange,"1-255",
  1473.                         FBTAG_Directory,default_directory,
  1474.                         FBTAG_DiskSpaceRequired,1024,
  1475.                         FBTAG_AutoJoin,TRUE,
  1476.                         TAG_END);
  1477.                     break;
  1478.                 case 4: /* Menus */
  1479.                     SetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,CFGTAG_DontSave,TRUE,
  1480.                         MNTAG_AccessRange,"1-255",
  1481.                         TAG_END);
  1482.                     break;
  1483.                 case 5: /* Message Bases */
  1484.                     SetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,CFGTAG_DontSave,TRUE,
  1485.                         MBTAG_AccessRange,"1-255",
  1486.                         MBTAG_QuoteHeader,default_quote_header,
  1487.                         MBTAG_AutoJoin,TRUE,
  1488.                         TAG_END);
  1489.                     break;
  1490.                 case 6: /* News */
  1491.                     SetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,CFGTAG_DontSave,TRUE,
  1492.                         NWSTAG_AccessRange,"1-255",
  1493.                         TAG_END);
  1494.                     break;
  1495.                 case 7: /* Nodes */
  1496.                     SetConfigTags(CFGTAG_Path,path,CFGTAG_Name,name,CFGTAG_DontSave,TRUE,
  1497.                         NDTAG_AccessRange,"1-255",
  1498.                         NDTAG_Type,NDTYP_Remote,
  1499.                         NDTAG_BufferSize,65536,
  1500.                         NDTAG_Baud,38400,
  1501.                         NDTAG_Handshaking,TRUE,
  1502.                         NDTAG_Command,default_node_command,
  1503.                         TAG_END);
  1504.                     break;
  1505.                 case 8: /* Protocols */
  1506.                     break;
  1507.             }
  1508.     }
  1509.